home *** CD-ROM | disk | FTP | other *** search
/ Tech Arsenal 1 / Tech Arsenal (Arsenal Computer).ISO / tek-01 / fontplot.zip / FONT.C < prev   
C/C++ Source or Header  |  1992-01-12  |  6KB  |  226 lines
  1. /*
  2.  
  3.   To use these routine you need to do this:
  4.  
  5.   begin
  6.  
  7.      initialize the video mode
  8.  
  9.      LoadFont();
  10.  
  11.  
  12.      // use LoadString just like printf
  13.  
  14.      LoadString( const char *format [, argument, ...]);
  15.  
  16.      // FontPrint always writes the last string send to LoadString
  17.  
  18.      FontPrint( xpos, ypos, color, FontSize );
  19.  
  20.  
  21.      close-down graphics mode
  22.  
  23.   end program.
  24.  
  25.   [jec]
  26.   Jay Clary
  27.   availible on EXEC-PC (ask for it by name)
  28.  
  29. */
  30.  
  31.  
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <conio.h>
  35. #include <malloc.h>
  36. #include <string.h>
  37. #include <stdarg.h>
  38.  
  39. #define BYTE  char
  40. #define UBYTE unsigned char
  41. #define WORD  int
  42. #define UWORD unsigned int
  43. #define LONG  long
  44. #define ULONG unsigned long
  45.  
  46. UBYTE FontSize;             // holds the Y-size of each font character
  47. UBYTE *font;                // Pointer to the binary font on disk
  48. char  FontFileName[80];     // the disk font file name
  49. char  FontString[255];      // holds the next string to plot
  50.  
  51.  
  52. void  LoadFont( void );
  53. void  LoadString( char *, ...);
  54. void  FontPrint( int, int, UBYTE, int );
  55. void  FontPlot( int, int, int, UBYTE, int );
  56.  
  57.  
  58.  
  59.  
  60. void LoadFont( void )
  61.  
  62.    {  FILE  *f;
  63.  
  64.       if ((font = (UBYTE *) malloc(4096)) == NULL)
  65.  
  66.          cprintf("Allocation Error! font in LoadFont");
  67.  
  68.  
  69.       if ((f = fopen( FontFileName, "rb" )) == NULL) {
  70.  
  71.          cprintf("Error Opening Font File: %s\r\n", FontFileName);
  72.          exit(99);
  73.  
  74.       }
  75.  
  76.  
  77.       if ( (fread(font, 1, 4096, f) ) != 4096) {
  78.  
  79.          cprintf("Error Loading Font File: %s\r\n", FontFileName);
  80.          exit(99);
  81.  
  82.       }
  83.  
  84.    }
  85.  
  86.  
  87. void LoadString( char *fmt, ...)
  88.  
  89.    {  va_list argptr;
  90.  
  91.       va_start( argptr, fmt );
  92.       vsprintf( FontString, fmt, argptr );
  93.       va_end( argptr );
  94.  
  95.    }
  96.  
  97.  
  98. void FontPrint( int x, int y, UBYTE c, int fs )
  99.  
  100.    {  int i, x1;
  101.  
  102.       x1 = x;
  103.  
  104.       for (i=0; i < strlen(FontString); i++, x1 += 8)
  105.  
  106.           FontPlot( FontString[i], x1, y, c, fs );
  107.  
  108.    }
  109.  
  110.  
  111.  
  112.  
  113. /*
  114.    The FontPlot was designed for a Trident 8900 chipset. Certain
  115.    assumptions are made for the particular project that I am
  116.    working on. If you plan on using this routine on a video card
  117.    with a Trident chipset in 1024x768x256 mode, it will work fine.
  118.    If you use another card in 1024x768x256, all you need change is
  119.    the bank-switching code. In any other video mode, you need to
  120.    write you own character-plotting routine.
  121.  
  122.    ************** WARNING ****************************************
  123.  
  124.           No clipping is performed - add it if you like. In my
  125.           situation, I don't require it and I just haven't had
  126.           time to add it.
  127.  
  128.  
  129.    If you need to roll you own -
  130.  
  131.       Font Size is the Y-Size of the characters in the font.
  132.       All of the fonts used by these routines are 8 pixels wide
  133.       so each line of the character is stored in a single byte.
  134.       You must pluck-off each bit, one by one. If the bit is
  135.       asserted (a '1' bit) the pixel on the screen is plotted
  136.       in the color of your choice
  137.  
  138. */
  139.  
  140.  
  141. void FontPlot( int index, int x, int y, UBYTE c, int FontSize )
  142.  
  143.    {  int y1;
  144.  
  145.       asm {      push ds
  146.  
  147.                  lds  si, font        // Load Font Offset
  148.                  mov  ax, index
  149.  
  150.                  mov  bx, FontSize    // Load the FontSize
  151.                  mul  bx              // Multiply the index * FontSize
  152.                  add  ax, si          // Add that to the font offset
  153.                  mov  si, ax          // Save that in SI
  154.  
  155.                  mov  ax, 0a000h      // point to the video segment
  156.                  mov  es, ax          // load the ES with it
  157.                  mov  ax, y           // move y-position into AX
  158.                  mov  y1, ax          // save a copy in y1
  159.                  mov  cx, FontSize    // load CX with FontSize (Y-counter)
  160.       }
  161.  
  162.       YLoop:
  163.       asm {      push cx              // save the current Y counter
  164.                  mov  ax, y1          // put video y-line in AX
  165.                  shl  ax, 1           // shift (y % 64) into AH
  166.                  shl  ax, 1           //
  167.  
  168.  
  169.                  /********************************/
  170.                  /*                              */
  171.                  /*   Trident 8900 bank-switch   */
  172.                  /*                              */
  173.                  /********************************/
  174.  
  175.                  mov  dx, 3c4h        // Trident port address
  176.                  mov  al, 0eh         // Switch-Bank function
  177.                  xor  ah, 02          // set proper page
  178.                  out  dx, ax          // do-it!
  179.  
  180.                  /****************************/
  181.                  /*                          */
  182.                  /*   End of bank-switch     */
  183.                  /*                          */
  184.                  /****************************/
  185.  
  186.  
  187.                  sub  bx, bx          // zeor-out BX
  188.                  mov  ax, y1          // move y1 into AX
  189.  
  190.                  mov  bh, al          // Swap low/high registers
  191.                  shl  bx, 1           //   shift left 2 times
  192.                  shl  bx, 1           //   = 10 shift left
  193.  
  194.                  add  bx, x           // Add in the x offset
  195.                  mov  dl, c           // move the color into DL
  196.  
  197.                  mov  al, ds:[si]     // get the font line (byte)
  198.                  mov  cx, 8           // 8 font pixels per byte
  199.       }
  200.  
  201.       XLoop:
  202.       asm {      test al, 0ffh        // check if font pixel is set
  203.                  jns  skipit          // if it's 0, jump around
  204.  
  205.                  mov  es:[bx], dl     // else move DL to the video pos
  206.       }
  207.  
  208.       skipit:
  209.       asm {      rol  al, 1           // rotate around for next font pixel
  210.  
  211.                  inc  bx              // point to next screen byte
  212.                  loop XLoop           // do the next X-pixels
  213.  
  214.                  mov  ax, y1          // get ready to inc y1
  215.                  inc  ax              // do-it
  216.                  mov  y1, ax          // save y1
  217.                  inc  si              // point to next font line (byte)
  218.                  pop  cx              // restore YLoop counter
  219.                  loop YLoop           // do the next Y-line
  220.  
  221.                  pop  ds              // All done, saddle-up & ride
  222.      }
  223.  
  224.    }
  225.  
  226.